package com.ourteam.product.requirement.dao;

import net.dao.BaseQueryBean;
import net.dao.BaseWhereCriterion;
import net.dao.IDataAccessInterface;

import org.apache.commons.lang.StringUtils;

import java.util.Arrays;
import java.util.List;
import java.util.Map;


/**
 * Template Name : DAO查询对象
 * Template Version : 1
 * Template Last Modfiy Date : Sat Aug 19 10:06:32 CST 2017
 * Auto Generate Date : 2018-05-03 16:45:26
  * Warning ! This file will be overwrite when regenerate !
  *
 */
public class ProductGlossaryDAOQueryBean extends BaseQueryBean {
    public ProductGlossaryDAOQueryBean() {
        super();
    }

    public ProductGlossaryDAOQueryBean(BaseQueryBean aQueryBean) {
        super(aQueryBean);
    }

    public ProductGlossaryDAOQueryBean(BaseQueryBean aQueryBean,
        Map tableReplaceMap) {
        super(aQueryBean, tableReplaceMap);
    }

    public Criteria createCriteria() {
        Criteria criteria = createCriteriaInternal();

        if (oredCriteria.size() == 0) {
            oredCriteria.add(criteria);
        }

        return criteria;
    }

    protected Criteria createCriteriaInternal() {
        return new Criteria(this);
    }

    public void addIdSelectProperty() {
        addIdSelectProperty("id");
    }

    public void addIdSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductGlossaryDAO.Id, aAlias);
        } else {
            addSelectProperty(IProductGlossaryDAO.Id, "id");
        }
    }

    public void addCodeSelectProperty() {
        addCodeSelectProperty("code");
    }

    public void addCodeSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductGlossaryDAO.Code, aAlias);
        } else {
            addSelectProperty(IProductGlossaryDAO.Code, "code");
        }
    }

    public void addContentSelectProperty() {
        addContentSelectProperty("content");
    }

    public void addContentSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductGlossaryDAO.Content, aAlias);
        } else {
            addSelectProperty(IProductGlossaryDAO.Content, "content");
        }
    }

    public void addCreateDateSelectProperty() {
        addCreateDateSelectProperty("createDate");
    }

    public void addCreateDateSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductGlossaryDAO.CreateDate, aAlias);
        } else {
            addSelectProperty(IProductGlossaryDAO.CreateDate, "createDate");
        }
    }

    public void addCreatorIdSelectProperty() {
        addCreatorIdSelectProperty("creatorId");
    }

    public void addCreatorIdSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductGlossaryDAO.CreatorId, aAlias);
        } else {
            addSelectProperty(IProductGlossaryDAO.CreatorId, "creatorId");
        }
    }

    public void addLastEditorIdSelectProperty() {
        addLastEditorIdSelectProperty("lastEditorId");
    }

    public void addLastEditorIdSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductGlossaryDAO.LastEditorId, aAlias);
        } else {
            addSelectProperty(IProductGlossaryDAO.LastEditorId, "lastEditorId");
        }
    }

    public void addLastEditDateSelectProperty() {
        addLastEditDateSelectProperty("lastEditDate");
    }

    public void addLastEditDateSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductGlossaryDAO.LastEditDate, aAlias);
        } else {
            addSelectProperty(IProductGlossaryDAO.LastEditDate, "lastEditDate");
        }
    }

    public void addNameSelectProperty() {
        addNameSelectProperty("name");
    }

    public void addNameSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductGlossaryDAO.Name, aAlias);
        } else {
            addSelectProperty(IProductGlossaryDAO.Name, "name");
        }
    }

    public void addProductIdSelectProperty() {
        addProductIdSelectProperty("productId");
    }

    public void addProductIdSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductGlossaryDAO.ProductId, aAlias);
        } else {
            addSelectProperty(IProductGlossaryDAO.ProductId, "productId");
        }
    }

    public void addRemarksSelectProperty() {
        addRemarksSelectProperty("remarks");
    }

    public void addRemarksSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductGlossaryDAO.Remarks, aAlias);
        } else {
            addSelectProperty(IProductGlossaryDAO.Remarks, "remarks");
        }
    }

    public void addStatusSelectProperty() {
        addStatusSelectProperty("status");
    }

    public void addStatusSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductGlossaryDAO.Status, aAlias);
        } else {
            addSelectProperty(IProductGlossaryDAO.Status, "status");
        }
    }

    public void addSinceVersionIdSelectProperty() {
        addSinceVersionIdSelectProperty("sinceVersionId");
    }

    public void addSinceVersionIdSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductGlossaryDAO.SinceVersionId, aAlias);
        } else {
            addSelectProperty(IProductGlossaryDAO.SinceVersionId,
                "sinceVersionId");
        }
    }

    public void addTypeSelectProperty() {
        addTypeSelectProperty("type");
    }

    public void addTypeSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductGlossaryDAO.Type, aAlias);
        } else {
            addSelectProperty(IProductGlossaryDAO.Type, "type");
        }
    }

    public void addLastEditorNameSelectProperty() {
        addLastEditorNameSelectProperty("lastEditorName");
    }

    public void addLastEditorNameSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductGlossaryDAO.LastEditorName, aAlias);
        } else {
            addSelectProperty(IProductGlossaryDAO.LastEditorName,
                "lastEditorName");
        }
    }

    public void addSinceVersionSelectProperty() {
        addSinceVersionSelectProperty("sinceVersion");
    }

    public void addSinceVersionSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductGlossaryDAO.SinceVersion, aAlias);
        } else {
            addSelectProperty(IProductGlossaryDAO.SinceVersion, "sinceVersion");
        }
    }

    public void addProductDefineIdSelectProperty() {
        addProductDefineIdSelectProperty("productDefineId");
    }

    public void addProductDefineIdSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductGlossaryDAO.ProductDefineId, aAlias);
        } else {
            addSelectProperty(IProductGlossaryDAO.ProductDefineId,
                "productDefineId");
        }
    }

    public void addAllSelectProperties() {
        addIdSelectProperty();

        addCodeSelectProperty();

        addContentSelectProperty();

        addCreateDateSelectProperty();

        addCreatorIdSelectProperty();

        addLastEditorIdSelectProperty();

        addLastEditDateSelectProperty();

        addNameSelectProperty();

        addProductIdSelectProperty();

        addRemarksSelectProperty();

        addStatusSelectProperty();

        addSinceVersionIdSelectProperty();

        addTypeSelectProperty();

        addLastEditorNameSelectProperty();

        addSinceVersionSelectProperty();

        addProductDefineIdSelectProperty();
    }

    public static class Criteria extends BaseWhereCriterion<ProductGlossaryDAOQueryBean> {
        protected Criteria(ProductGlossaryDAOQueryBean aParentObject) {
            super(aParentObject);
        }

        public Criteria andIdIsNull() {
            addCriterion(IProductGlossaryDAO.Id + " is null");

            return this;
        }

        public Criteria andIdIsNotNull() {
            addCriterion(IProductGlossaryDAO.Id + " is not null");

            return this;
        }

        public Criteria andIdIsNotEmpty() {
            addCriterion(IProductGlossaryDAO.Id + " is not null AND " +
                IProductGlossaryDAO.Id + " <> ''");

            return this;
        }

        public Criteria andIdIsEmpty() {
            addCriterion("(" + IProductGlossaryDAO.Id + " is null OR " +
                IProductGlossaryDAO.Id + " = '')");

            return this;
        }

        public Criteria andIdEqualTo(long value) {
            return andIdEqualTo(Long.valueOf(value));
        }

        public Criteria andIdEqualTo(java.lang.Long value) {
            addCriterion(IProductGlossaryDAO.Id + " = ", value, "id");

            return this;
        }

        public Criteria andIdEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.Id);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andIdEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.Id + " = ", subQueryBean, dao);

            return this;
        }

        public Criteria andIdNotEqualTo(long value) {
            return andIdNotEqualTo(Long.valueOf(value));
        }

        public Criteria andIdNotEqualTo(java.lang.Long value) {
            addCriterion(IProductGlossaryDAO.Id + " <>", value, "id");

            return this;
        }

        public Criteria andIdNotEqualToOrIsNull(long value) {
            return andIdNotEqualToOrIsNull(Long.valueOf(value));
        }

        public Criteria andIdNotEqualToOrIsNull(java.lang.Long value) {
            addCriterion(IProductGlossaryDAO.Id + " is null OR " +
                IProductGlossaryDAO.Id + " <>", value, "id");

            return this;
        }

        public Criteria andIdNotEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.Id);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andIdNotEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.Id + " <> ", subQueryBean, dao);

            return this;
        }

        public Criteria andIdGreaterThan(long value) {
            return andIdGreaterThan(Long.valueOf(value));
        }

        public Criteria andIdGreaterThan(java.lang.Long value) {
            addCriterion(IProductGlossaryDAO.Id + " >", value, "id");

            return this;
        }

        public Criteria andIdGreaterThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.Id);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andIdGreaterThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.Id + " > ", subQueryBean, dao);

            return this;
        }

        public Criteria andIdGreaterThanOrEqualTo(long value) {
            return andIdGreaterThanOrEqualTo(Long.valueOf(value));
        }

        public Criteria andIdGreaterThanOrEqualTo(java.lang.Long value) {
            addCriterion(IProductGlossaryDAO.Id + " >=", value, "id");

            return this;
        }

        public Criteria andIdGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.Id);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andIdGreaterThanOrEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.Id + " >= ", subQueryBean, dao);

            return this;
        }

        public Criteria andIdLessThan(long value) {
            return andIdLessThan(Long.valueOf(value));
        }

        public Criteria andIdLessThan(java.lang.Long value) {
            addCriterion(IProductGlossaryDAO.Id + " <", value, "id");

            return this;
        }

        public Criteria andIdLessThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.Id);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andIdLessThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.Id + " < ", subQueryBean, dao);

            return this;
        }

        public Criteria andIdLessThanOrEqualTo(long value) {
            return andIdLessThanOrEqualTo(Long.valueOf(value));
        }

        public Criteria andIdLessThanOrEqualTo(java.lang.Long value) {
            addCriterion(IProductGlossaryDAO.Id + " <=", value, "id");

            return this;
        }

        public Criteria andIdLessThanOrEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.Id);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andIdLessThanOrEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.Id + " <= ", subQueryBean, dao);

            return this;
        }

        public Criteria andIdIn(long[] values) {
            if (values.length == 1) {
                return andIdEqualTo((java.lang.Long) values[0]);
            } else {
                addCriterion(IProductGlossaryDAO.Id + " in", values, "id");

                return this;
            }
        }

        public Criteria andIdNotIn(long[] values) {
            if (values.length == 1) {
                return andIdNotEqualTo((java.lang.Long) values[0]);
            } else {
                addCriterion(IProductGlossaryDAO.Id + " not in", values, "id");

                return this;
            }
        }

        public Criteria andIdIn(List<java.lang.Long> values) {
            if (values.size() == 1) {
                return andIdEqualTo(values.get(0));
            } else {
                addCriterion(IProductGlossaryDAO.Id + " in", values, "id");

                return this;
            }
        }

        public Criteria andIdNotIn(List<java.lang.Long> values) {
            if (values.size() == 1) {
                return andIdNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductGlossaryDAO.Id + " not in", values, "id");

                return this;
            }
        }

        public Criteria andIdIn(java.lang.Long[] values) {
            if (values.length == 1) {
                return andIdEqualTo(values[0]);
            } else {
                addCriterion(IProductGlossaryDAO.Id + " in",
                    Arrays.asList(values), "id");

                return this;
            }
        }

        public Criteria andIdNotIn(java.lang.Long[] values) {
            if (values.length == 1) {
                return andIdNotEqualTo(values[0]);
            } else {
                addCriterion(IProductGlossaryDAO.Id + " not in",
                    Arrays.asList(values), "id");

                return this;
            }
        }

        public Criteria andIdIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.Id + " in ", subQueryBean, dao);

            return this;
        }

        public Criteria andIdNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.Id + " not in ", subQueryBean, dao);

            return this;
        }

        public Criteria andIdBetween(long value1, long value2) {
            addCriterion(IProductGlossaryDAO.Id + " between", value1, value2,
                "id");

            return this;
        }

        public Criteria andIdBetween(java.lang.Long value1,
            java.lang.Long value2) {
            addCriterion(IProductGlossaryDAO.Id + " between", value1, value2,
                "id");

            return this;
        }

        public Criteria andIdNotBetween(long value1, long value2) {
            addCriterion(IProductGlossaryDAO.Id + " not between", value1,
                value2, "id");

            return this;
        }

        public Criteria andIdNotBetween(java.lang.Long value1,
            java.lang.Long value2) {
            addCriterion(IProductGlossaryDAO.Id + " not between", value1,
                value2, "id");

            return this;
        }

        public Criteria andCodeIsNull() {
            addCriterion(IProductGlossaryDAO.Code + " is null");

            return this;
        }

        public Criteria andCodeIsNotNull() {
            addCriterion(IProductGlossaryDAO.Code + " is not null");

            return this;
        }

        public Criteria andCodeIsNotEmpty() {
            addCriterion(IProductGlossaryDAO.Code + " is not null AND " +
                IProductGlossaryDAO.Code + " <> ''");

            return this;
        }

        public Criteria andCodeIsEmpty() {
            addCriterion("(" + IProductGlossaryDAO.Code + " is null OR " +
                IProductGlossaryDAO.Code + " = '')");

            return this;
        }

        public Criteria andCodeEqualTo(String value) {
            addCriterion(IProductGlossaryDAO.Code + " = ", value, "code");

            return this;
        }

        public Criteria andCodeEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.Code);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andCodeEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.Code + " = ", subQueryBean, dao);

            return this;
        }

        public Criteria andCodeNotEqualTo(String value) {
            addCriterion(IProductGlossaryDAO.Code + " <>", value, "code");

            return this;
        }

        public Criteria andCodeNotEqualToOrIsNull(String value) {
            addCriterion(IProductGlossaryDAO.Code + " is null OR " +
                IProductGlossaryDAO.Code + " <>", value, "code");

            return this;
        }

        public Criteria andCodeNotEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.Code);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andCodeNotEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.Code + " <> ", subQueryBean, dao);

            return this;
        }

        public Criteria andCodeGreaterThan(String value) {
            addCriterion(IProductGlossaryDAO.Code + " >", value, "code");

            return this;
        }

        public Criteria andCodeGreaterThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.Code);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andCodeGreaterThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.Code + " > ", subQueryBean, dao);

            return this;
        }

        public Criteria andCodeGreaterThanOrEqualTo(String value) {
            addCriterion(IProductGlossaryDAO.Code + " >=", value, "code");

            return this;
        }

        public Criteria andCodeGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.Code);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andCodeGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.Code + " >= ", subQueryBean, dao);

            return this;
        }

        public Criteria andCodeLessThan(String value) {
            addCriterion(IProductGlossaryDAO.Code + " <", value, "code");

            return this;
        }

        public Criteria andCodeLessThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.Code);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andCodeLessThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.Code + " < ", subQueryBean, dao);

            return this;
        }

        public Criteria andCodeLessThanOrEqualTo(String value) {
            addCriterion(IProductGlossaryDAO.Code + " <=", value, "code");

            return this;
        }

        public Criteria andCodeLessThanOrEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.Code);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andCodeLessThanOrEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.Code + " <= ", subQueryBean, dao);

            return this;
        }

        public Criteria andCodeLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductGlossaryDAO.Code + " like", buffer.toString(),
                "code");

            return this;
        }

        public Criteria andCodeNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductGlossaryDAO.Code + " not like",
                buffer.toString(), "code");

            return this;
        }

        public Criteria andCodeIn(List<String> values) {
            if (values.size() == 1) {
                return andCodeEqualTo(values.get(0));
            } else {
                addCriterion(IProductGlossaryDAO.Code + " in", values, "code");

                return this;
            }
        }

        public Criteria andCodeNotIn(List<String> values) {
            if (values.size() == 1) {
                return andCodeNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductGlossaryDAO.Code + " not in", values,
                    "code");

                return this;
            }
        }

        public Criteria andCodeIn(String[] values) {
            if (values.length == 1) {
                return andCodeEqualTo(values[0]);
            } else {
                addCriterion(IProductGlossaryDAO.Code + " in",
                    Arrays.asList(values), "code");

                return this;
            }
        }

        public Criteria andCodeNotIn(String[] values) {
            if (values.length == 1) {
                return andCodeNotEqualTo(values[0]);
            } else {
                addCriterion(IProductGlossaryDAO.Code + " not in",
                    Arrays.asList(values), "code");

                return this;
            }
        }

        public Criteria andCodeIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.Code + " in ", subQueryBean, dao);

            return this;
        }

        public Criteria andCodeNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.Code + " not in ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andCodeBetween(String value1, String value2) {
            addCriterion(IProductGlossaryDAO.Code + " between", value1, value2,
                "code");

            return this;
        }

        public Criteria andCodeNotBetween(String value1, String value2) {
            addCriterion(IProductGlossaryDAO.Code + " not between", value1,
                value2, "code");

            return this;
        }

        public Criteria andContentIsNull() {
            addCriterion(IProductGlossaryDAO.Content + " is null");

            return this;
        }

        public Criteria andContentIsNotNull() {
            addCriterion(IProductGlossaryDAO.Content + " is not null");

            return this;
        }

        public Criteria andContentIsNotEmpty() {
            addCriterion(IProductGlossaryDAO.Content + " is not null AND " +
                IProductGlossaryDAO.Content + " <> ''");

            return this;
        }

        public Criteria andContentIsEmpty() {
            addCriterion("(" + IProductGlossaryDAO.Content + " is null OR " +
                IProductGlossaryDAO.Content + " = '')");

            return this;
        }

        public Criteria andContentEqualTo(String value) {
            addCriterion(IProductGlossaryDAO.Content + " = ", value, "content");

            return this;
        }

        public Criteria andContentEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.Content);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andContentEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.Content + " = ", subQueryBean, dao);

            return this;
        }

        public Criteria andContentNotEqualTo(String value) {
            addCriterion(IProductGlossaryDAO.Content + " <>", value, "content");

            return this;
        }

        public Criteria andContentNotEqualToOrIsNull(String value) {
            addCriterion(IProductGlossaryDAO.Content + " is null OR " +
                IProductGlossaryDAO.Content + " <>", value, "content");

            return this;
        }

        public Criteria andContentNotEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.Content);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andContentNotEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.Content + " <> ", subQueryBean, dao);

            return this;
        }

        public Criteria andContentGreaterThan(String value) {
            addCriterion(IProductGlossaryDAO.Content + " >", value, "content");

            return this;
        }

        public Criteria andContentGreaterThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.Content);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andContentGreaterThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.Content + " > ", subQueryBean, dao);

            return this;
        }

        public Criteria andContentGreaterThanOrEqualTo(String value) {
            addCriterion(IProductGlossaryDAO.Content + " >=", value, "content");

            return this;
        }

        public Criteria andContentGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.Content);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andContentGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.Content + " >= ", subQueryBean, dao);

            return this;
        }

        public Criteria andContentLessThan(String value) {
            addCriterion(IProductGlossaryDAO.Content + " <", value, "content");

            return this;
        }

        public Criteria andContentLessThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.Content);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andContentLessThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.Content + " < ", subQueryBean, dao);

            return this;
        }

        public Criteria andContentLessThanOrEqualTo(String value) {
            addCriterion(IProductGlossaryDAO.Content + " <=", value, "content");

            return this;
        }

        public Criteria andContentLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.Content);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andContentLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.Content + " <= ", subQueryBean, dao);

            return this;
        }

        public Criteria andContentLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductGlossaryDAO.Content + " like",
                buffer.toString(), "content");

            return this;
        }

        public Criteria andContentNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductGlossaryDAO.Content + " not like",
                buffer.toString(), "content");

            return this;
        }

        public Criteria andContentIn(List<String> values) {
            if (values.size() == 1) {
                return andContentEqualTo(values.get(0));
            } else {
                addCriterion(IProductGlossaryDAO.Content + " in", values,
                    "content");

                return this;
            }
        }

        public Criteria andContentNotIn(List<String> values) {
            if (values.size() == 1) {
                return andContentNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductGlossaryDAO.Content + " not in", values,
                    "content");

                return this;
            }
        }

        public Criteria andContentIn(String[] values) {
            if (values.length == 1) {
                return andContentEqualTo(values[0]);
            } else {
                addCriterion(IProductGlossaryDAO.Content + " in",
                    Arrays.asList(values), "content");

                return this;
            }
        }

        public Criteria andContentNotIn(String[] values) {
            if (values.length == 1) {
                return andContentNotEqualTo(values[0]);
            } else {
                addCriterion(IProductGlossaryDAO.Content + " not in",
                    Arrays.asList(values), "content");

                return this;
            }
        }

        public Criteria andContentIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.Content + " in ", subQueryBean, dao);

            return this;
        }

        public Criteria andContentNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.Content + " not in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andContentBetween(String value1, String value2) {
            addCriterion(IProductGlossaryDAO.Content + " between", value1,
                value2, "content");

            return this;
        }

        public Criteria andContentNotBetween(String value1, String value2) {
            addCriterion(IProductGlossaryDAO.Content + " not between", value1,
                value2, "content");

            return this;
        }

        public Criteria andCreateDateIsNull() {
            addCriterion(IProductGlossaryDAO.CreateDate + " is null");

            return this;
        }

        public Criteria andCreateDateIsNotNull() {
            addCriterion(IProductGlossaryDAO.CreateDate + " is not null");

            return this;
        }

        public Criteria andCreateDateIsNotEmpty() {
            addCriterion(IProductGlossaryDAO.CreateDate + " is not null AND " +
                IProductGlossaryDAO.CreateDate + " <> ''");

            return this;
        }

        public Criteria andCreateDateIsEmpty() {
            addCriterion("(" + IProductGlossaryDAO.CreateDate + " is null OR " +
                IProductGlossaryDAO.CreateDate + " = '')");

            return this;
        }

        public Criteria andCreateDateEqualTo(java.util.Date value) {
            addCriterionForJDBCDate(IProductGlossaryDAO.CreateDate + " = ",
                value, "createDate");

            return this;
        }

        public Criteria andCreateDateEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.CreateDate);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andCreateDateEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.CreateDate + " = ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andCreateDateNotEqualTo(java.util.Date value) {
            addCriterionForJDBCDate(IProductGlossaryDAO.CreateDate + " <>",
                value, "createDate");

            return this;
        }

        public Criteria andCreateDateNotEqualToOrIsNull(java.util.Date value) {
            addCriterionForJDBCDate(IProductGlossaryDAO.CreateDate +
                " is null OR " + IProductGlossaryDAO.CreateDate + " <>", value,
                "createDate");

            return this;
        }

        public Criteria andCreateDateNotEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.CreateDate);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andCreateDateNotEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.CreateDate + " <> ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andCreateDateGreaterThan(java.util.Date value) {
            addCriterionForJDBCDate(IProductGlossaryDAO.CreateDate + " >",
                value, "createDate");

            return this;
        }

        public Criteria andCreateDateGreaterThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.CreateDate);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andCreateDateGreaterThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.CreateDate + " > ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andCreateDateGreaterThanOrEqualTo(java.util.Date value) {
            addCriterionForJDBCDate(IProductGlossaryDAO.CreateDate + " >=",
                value, "createDate");

            return this;
        }

        public Criteria andCreateDateGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.CreateDate);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andCreateDateGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.CreateDate + " >= ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andCreateDateLessThan(java.util.Date value) {
            addCriterionForJDBCDate(IProductGlossaryDAO.CreateDate + " <",
                value, "createDate");

            return this;
        }

        public Criteria andCreateDateLessThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.CreateDate);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andCreateDateLessThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.CreateDate + " < ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andCreateDateLessThanOrEqualTo(java.util.Date value) {
            addCriterionForJDBCDate(IProductGlossaryDAO.CreateDate + " <=",
                value, "createDate");

            return this;
        }

        public Criteria andCreateDateLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.CreateDate);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andCreateDateLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.CreateDate + " <= ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andCreateDateIn(List<java.util.Date> values) {
            if (values.size() == 1) {
                return andCreateDateEqualTo(values.get(0));
            } else {
                addCriterionForJDBCDate(IProductGlossaryDAO.CreateDate + " in",
                    values, "createDate");

                return this;
            }
        }

        public Criteria andCreateDateNotIn(List<java.util.Date> values) {
            if (values.size() == 1) {
                return andCreateDateNotEqualTo(values.get(0));
            } else {
                addCriterionForJDBCDate(IProductGlossaryDAO.CreateDate +
                    " not in", values, "createDate");

                return this;
            }
        }

        public Criteria andCreateDateIn(java.util.Date[] values) {
            if (values.length == 1) {
                return andCreateDateEqualTo(values[0]);
            } else {
                addCriterionForJDBCDate(IProductGlossaryDAO.CreateDate + " in",
                    Arrays.asList(values), "createDate");

                return this;
            }
        }

        public Criteria andCreateDateNotIn(java.util.Date[] values) {
            if (values.length == 1) {
                return andCreateDateNotEqualTo(values[0]);
            } else {
                addCriterionForJDBCDate(IProductGlossaryDAO.CreateDate +
                    " not in", Arrays.asList(values), "createDate");

                return this;
            }
        }

        public Criteria andCreateDateIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.CreateDate + " in ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andCreateDateNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.CreateDate + " not in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andCreateDateBetween(java.util.Date value1,
            java.util.Date value2) {
            addCriterionForJDBCDate(IProductGlossaryDAO.CreateDate +
                " between", value1, value2, "createDate");

            return this;
        }

        public Criteria andCreateDateNotBetween(java.util.Date value1,
            java.util.Date value2) {
            addCriterionForJDBCDate(IProductGlossaryDAO.CreateDate +
                " not between", value1, value2, "createDate");

            return this;
        }

        public Criteria andCreatorIdIsNull() {
            addCriterion(IProductGlossaryDAO.CreatorId + " is null");

            return this;
        }

        public Criteria andCreatorIdIsNotNull() {
            addCriterion(IProductGlossaryDAO.CreatorId + " is not null");

            return this;
        }

        public Criteria andCreatorIdIsNotEmpty() {
            addCriterion(IProductGlossaryDAO.CreatorId + " is not null AND " +
                IProductGlossaryDAO.CreatorId + " <> ''");

            return this;
        }

        public Criteria andCreatorIdIsEmpty() {
            addCriterion("(" + IProductGlossaryDAO.CreatorId + " is null OR " +
                IProductGlossaryDAO.CreatorId + " = '')");

            return this;
        }

        public Criteria andCreatorIdEqualTo(long value) {
            return andCreatorIdEqualTo(Long.valueOf(value));
        }

        public Criteria andCreatorIdEqualTo(java.lang.Long value) {
            addCriterion(IProductGlossaryDAO.CreatorId + " = ", value,
                "creatorId");

            return this;
        }

        public Criteria andCreatorIdEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.CreatorId);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andCreatorIdEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.CreatorId + " = ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andCreatorIdNotEqualTo(long value) {
            return andCreatorIdNotEqualTo(Long.valueOf(value));
        }

        public Criteria andCreatorIdNotEqualTo(java.lang.Long value) {
            addCriterion(IProductGlossaryDAO.CreatorId + " <>", value,
                "creatorId");

            return this;
        }

        public Criteria andCreatorIdNotEqualToOrIsNull(long value) {
            return andCreatorIdNotEqualToOrIsNull(Long.valueOf(value));
        }

        public Criteria andCreatorIdNotEqualToOrIsNull(java.lang.Long value) {
            addCriterion(IProductGlossaryDAO.CreatorId + " is null OR " +
                IProductGlossaryDAO.CreatorId + " <>", value, "creatorId");

            return this;
        }

        public Criteria andCreatorIdNotEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.CreatorId);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andCreatorIdNotEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.CreatorId + " <> ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andCreatorIdGreaterThan(long value) {
            return andCreatorIdGreaterThan(Long.valueOf(value));
        }

        public Criteria andCreatorIdGreaterThan(java.lang.Long value) {
            addCriterion(IProductGlossaryDAO.CreatorId + " >", value,
                "creatorId");

            return this;
        }

        public Criteria andCreatorIdGreaterThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.CreatorId);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andCreatorIdGreaterThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.CreatorId + " > ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andCreatorIdGreaterThanOrEqualTo(long value) {
            return andCreatorIdGreaterThanOrEqualTo(Long.valueOf(value));
        }

        public Criteria andCreatorIdGreaterThanOrEqualTo(java.lang.Long value) {
            addCriterion(IProductGlossaryDAO.CreatorId + " >=", value,
                "creatorId");

            return this;
        }

        public Criteria andCreatorIdGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.CreatorId);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andCreatorIdGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.CreatorId + " >= ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andCreatorIdLessThan(long value) {
            return andCreatorIdLessThan(Long.valueOf(value));
        }

        public Criteria andCreatorIdLessThan(java.lang.Long value) {
            addCriterion(IProductGlossaryDAO.CreatorId + " <", value,
                "creatorId");

            return this;
        }

        public Criteria andCreatorIdLessThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.CreatorId);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andCreatorIdLessThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.CreatorId + " < ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andCreatorIdLessThanOrEqualTo(long value) {
            return andCreatorIdLessThanOrEqualTo(Long.valueOf(value));
        }

        public Criteria andCreatorIdLessThanOrEqualTo(java.lang.Long value) {
            addCriterion(IProductGlossaryDAO.CreatorId + " <=", value,
                "creatorId");

            return this;
        }

        public Criteria andCreatorIdLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.CreatorId);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andCreatorIdLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.CreatorId + " <= ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andCreatorIdIn(long[] values) {
            if (values.length == 1) {
                return andCreatorIdEqualTo((java.lang.Long) values[0]);
            } else {
                addCriterion(IProductGlossaryDAO.CreatorId + " in", values,
                    "creatorId");

                return this;
            }
        }

        public Criteria andCreatorIdNotIn(long[] values) {
            if (values.length == 1) {
                return andCreatorIdNotEqualTo((java.lang.Long) values[0]);
            } else {
                addCriterion(IProductGlossaryDAO.CreatorId + " not in", values,
                    "creatorId");

                return this;
            }
        }

        public Criteria andCreatorIdIn(List<java.lang.Long> values) {
            if (values.size() == 1) {
                return andCreatorIdEqualTo(values.get(0));
            } else {
                addCriterion(IProductGlossaryDAO.CreatorId + " in", values,
                    "creatorId");

                return this;
            }
        }

        public Criteria andCreatorIdNotIn(List<java.lang.Long> values) {
            if (values.size() == 1) {
                return andCreatorIdNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductGlossaryDAO.CreatorId + " not in", values,
                    "creatorId");

                return this;
            }
        }

        public Criteria andCreatorIdIn(java.lang.Long[] values) {
            if (values.length == 1) {
                return andCreatorIdEqualTo(values[0]);
            } else {
                addCriterion(IProductGlossaryDAO.CreatorId + " in",
                    Arrays.asList(values), "creatorId");

                return this;
            }
        }

        public Criteria andCreatorIdNotIn(java.lang.Long[] values) {
            if (values.length == 1) {
                return andCreatorIdNotEqualTo(values[0]);
            } else {
                addCriterion(IProductGlossaryDAO.CreatorId + " not in",
                    Arrays.asList(values), "creatorId");

                return this;
            }
        }

        public Criteria andCreatorIdIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.CreatorId + " in ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andCreatorIdNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.CreatorId + " not in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andCreatorIdBetween(long value1, long value2) {
            addCriterion(IProductGlossaryDAO.CreatorId + " between", value1,
                value2, "creatorId");

            return this;
        }

        public Criteria andCreatorIdBetween(java.lang.Long value1,
            java.lang.Long value2) {
            addCriterion(IProductGlossaryDAO.CreatorId + " between", value1,
                value2, "creatorId");

            return this;
        }

        public Criteria andCreatorIdNotBetween(long value1, long value2) {
            addCriterion(IProductGlossaryDAO.CreatorId + " not between",
                value1, value2, "creatorId");

            return this;
        }

        public Criteria andCreatorIdNotBetween(java.lang.Long value1,
            java.lang.Long value2) {
            addCriterion(IProductGlossaryDAO.CreatorId + " not between",
                value1, value2, "creatorId");

            return this;
        }

        public Criteria andLastEditorIdIsNull() {
            addCriterion(IProductGlossaryDAO.LastEditorId + " is null");

            return this;
        }

        public Criteria andLastEditorIdIsNotNull() {
            addCriterion(IProductGlossaryDAO.LastEditorId + " is not null");

            return this;
        }

        public Criteria andLastEditorIdIsNotEmpty() {
            addCriterion(IProductGlossaryDAO.LastEditorId +
                " is not null AND " + IProductGlossaryDAO.LastEditorId +
                " <> ''");

            return this;
        }

        public Criteria andLastEditorIdIsEmpty() {
            addCriterion("(" + IProductGlossaryDAO.LastEditorId +
                " is null OR " + IProductGlossaryDAO.LastEditorId + " = '')");

            return this;
        }

        public Criteria andLastEditorIdEqualTo(long value) {
            return andLastEditorIdEqualTo(Long.valueOf(value));
        }

        public Criteria andLastEditorIdEqualTo(java.lang.Long value) {
            addCriterion(IProductGlossaryDAO.LastEditorId + " = ", value,
                "lastEditorId");

            return this;
        }

        public Criteria andLastEditorIdEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.LastEditorId);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andLastEditorIdEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.LastEditorId + " = ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andLastEditorIdNotEqualTo(long value) {
            return andLastEditorIdNotEqualTo(Long.valueOf(value));
        }

        public Criteria andLastEditorIdNotEqualTo(java.lang.Long value) {
            addCriterion(IProductGlossaryDAO.LastEditorId + " <>", value,
                "lastEditorId");

            return this;
        }

        public Criteria andLastEditorIdNotEqualToOrIsNull(long value) {
            return andLastEditorIdNotEqualToOrIsNull(Long.valueOf(value));
        }

        public Criteria andLastEditorIdNotEqualToOrIsNull(java.lang.Long value) {
            addCriterion(IProductGlossaryDAO.LastEditorId + " is null OR " +
                IProductGlossaryDAO.LastEditorId + " <>", value, "lastEditorId");

            return this;
        }

        public Criteria andLastEditorIdNotEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.LastEditorId);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andLastEditorIdNotEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.LastEditorId + " <> ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andLastEditorIdGreaterThan(long value) {
            return andLastEditorIdGreaterThan(Long.valueOf(value));
        }

        public Criteria andLastEditorIdGreaterThan(java.lang.Long value) {
            addCriterion(IProductGlossaryDAO.LastEditorId + " >", value,
                "lastEditorId");

            return this;
        }

        public Criteria andLastEditorIdGreaterThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.LastEditorId);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andLastEditorIdGreaterThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.LastEditorId + " > ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andLastEditorIdGreaterThanOrEqualTo(long value) {
            return andLastEditorIdGreaterThanOrEqualTo(Long.valueOf(value));
        }

        public Criteria andLastEditorIdGreaterThanOrEqualTo(
            java.lang.Long value) {
            addCriterion(IProductGlossaryDAO.LastEditorId + " >=", value,
                "lastEditorId");

            return this;
        }

        public Criteria andLastEditorIdGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.LastEditorId);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andLastEditorIdGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.LastEditorId + " >= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andLastEditorIdLessThan(long value) {
            return andLastEditorIdLessThan(Long.valueOf(value));
        }

        public Criteria andLastEditorIdLessThan(java.lang.Long value) {
            addCriterion(IProductGlossaryDAO.LastEditorId + " <", value,
                "lastEditorId");

            return this;
        }

        public Criteria andLastEditorIdLessThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.LastEditorId);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andLastEditorIdLessThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.LastEditorId + " < ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andLastEditorIdLessThanOrEqualTo(long value) {
            return andLastEditorIdLessThanOrEqualTo(Long.valueOf(value));
        }

        public Criteria andLastEditorIdLessThanOrEqualTo(java.lang.Long value) {
            addCriterion(IProductGlossaryDAO.LastEditorId + " <=", value,
                "lastEditorId");

            return this;
        }

        public Criteria andLastEditorIdLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.LastEditorId);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andLastEditorIdLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.LastEditorId + " <= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andLastEditorIdIn(long[] values) {
            if (values.length == 1) {
                return andLastEditorIdEqualTo((java.lang.Long) values[0]);
            } else {
                addCriterion(IProductGlossaryDAO.LastEditorId + " in", values,
                    "lastEditorId");

                return this;
            }
        }

        public Criteria andLastEditorIdNotIn(long[] values) {
            if (values.length == 1) {
                return andLastEditorIdNotEqualTo((java.lang.Long) values[0]);
            } else {
                addCriterion(IProductGlossaryDAO.LastEditorId + " not in",
                    values, "lastEditorId");

                return this;
            }
        }

        public Criteria andLastEditorIdIn(List<java.lang.Long> values) {
            if (values.size() == 1) {
                return andLastEditorIdEqualTo(values.get(0));
            } else {
                addCriterion(IProductGlossaryDAO.LastEditorId + " in", values,
                    "lastEditorId");

                return this;
            }
        }

        public Criteria andLastEditorIdNotIn(List<java.lang.Long> values) {
            if (values.size() == 1) {
                return andLastEditorIdNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductGlossaryDAO.LastEditorId + " not in",
                    values, "lastEditorId");

                return this;
            }
        }

        public Criteria andLastEditorIdIn(java.lang.Long[] values) {
            if (values.length == 1) {
                return andLastEditorIdEqualTo(values[0]);
            } else {
                addCriterion(IProductGlossaryDAO.LastEditorId + " in",
                    Arrays.asList(values), "lastEditorId");

                return this;
            }
        }

        public Criteria andLastEditorIdNotIn(java.lang.Long[] values) {
            if (values.length == 1) {
                return andLastEditorIdNotEqualTo(values[0]);
            } else {
                addCriterion(IProductGlossaryDAO.LastEditorId + " not in",
                    Arrays.asList(values), "lastEditorId");

                return this;
            }
        }

        public Criteria andLastEditorIdIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.LastEditorId + " in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andLastEditorIdNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.LastEditorId + " not in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andLastEditorIdBetween(long value1, long value2) {
            addCriterion(IProductGlossaryDAO.LastEditorId + " between", value1,
                value2, "lastEditorId");

            return this;
        }

        public Criteria andLastEditorIdBetween(java.lang.Long value1,
            java.lang.Long value2) {
            addCriterion(IProductGlossaryDAO.LastEditorId + " between", value1,
                value2, "lastEditorId");

            return this;
        }

        public Criteria andLastEditorIdNotBetween(long value1, long value2) {
            addCriterion(IProductGlossaryDAO.LastEditorId + " not between",
                value1, value2, "lastEditorId");

            return this;
        }

        public Criteria andLastEditorIdNotBetween(java.lang.Long value1,
            java.lang.Long value2) {
            addCriterion(IProductGlossaryDAO.LastEditorId + " not between",
                value1, value2, "lastEditorId");

            return this;
        }

        public Criteria andLastEditDateIsNull() {
            addCriterion(IProductGlossaryDAO.LastEditDate + " is null");

            return this;
        }

        public Criteria andLastEditDateIsNotNull() {
            addCriterion(IProductGlossaryDAO.LastEditDate + " is not null");

            return this;
        }

        public Criteria andLastEditDateIsNotEmpty() {
            addCriterion(IProductGlossaryDAO.LastEditDate +
                " is not null AND " + IProductGlossaryDAO.LastEditDate +
                " <> ''");

            return this;
        }

        public Criteria andLastEditDateIsEmpty() {
            addCriterion("(" + IProductGlossaryDAO.LastEditDate +
                " is null OR " + IProductGlossaryDAO.LastEditDate + " = '')");

            return this;
        }

        public Criteria andLastEditDateEqualTo(java.util.Date value) {
            addCriterionForJDBCDate(IProductGlossaryDAO.LastEditDate + " = ",
                value, "lastEditDate");

            return this;
        }

        public Criteria andLastEditDateEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.LastEditDate);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andLastEditDateEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.LastEditDate + " = ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andLastEditDateNotEqualTo(java.util.Date value) {
            addCriterionForJDBCDate(IProductGlossaryDAO.LastEditDate + " <>",
                value, "lastEditDate");

            return this;
        }

        public Criteria andLastEditDateNotEqualToOrIsNull(java.util.Date value) {
            addCriterionForJDBCDate(IProductGlossaryDAO.LastEditDate +
                " is null OR " + IProductGlossaryDAO.LastEditDate + " <>",
                value, "lastEditDate");

            return this;
        }

        public Criteria andLastEditDateNotEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.LastEditDate);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andLastEditDateNotEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.LastEditDate + " <> ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andLastEditDateGreaterThan(java.util.Date value) {
            addCriterionForJDBCDate(IProductGlossaryDAO.LastEditDate + " >",
                value, "lastEditDate");

            return this;
        }

        public Criteria andLastEditDateGreaterThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.LastEditDate);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andLastEditDateGreaterThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.LastEditDate + " > ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andLastEditDateGreaterThanOrEqualTo(
            java.util.Date value) {
            addCriterionForJDBCDate(IProductGlossaryDAO.LastEditDate + " >=",
                value, "lastEditDate");

            return this;
        }

        public Criteria andLastEditDateGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.LastEditDate);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andLastEditDateGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.LastEditDate + " >= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andLastEditDateLessThan(java.util.Date value) {
            addCriterionForJDBCDate(IProductGlossaryDAO.LastEditDate + " <",
                value, "lastEditDate");

            return this;
        }

        public Criteria andLastEditDateLessThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.LastEditDate);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andLastEditDateLessThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.LastEditDate + " < ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andLastEditDateLessThanOrEqualTo(java.util.Date value) {
            addCriterionForJDBCDate(IProductGlossaryDAO.LastEditDate + " <=",
                value, "lastEditDate");

            return this;
        }

        public Criteria andLastEditDateLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.LastEditDate);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andLastEditDateLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.LastEditDate + " <= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andLastEditDateIn(List<java.util.Date> values) {
            if (values.size() == 1) {
                return andLastEditDateEqualTo(values.get(0));
            } else {
                addCriterionForJDBCDate(IProductGlossaryDAO.LastEditDate +
                    " in", values, "lastEditDate");

                return this;
            }
        }

        public Criteria andLastEditDateNotIn(List<java.util.Date> values) {
            if (values.size() == 1) {
                return andLastEditDateNotEqualTo(values.get(0));
            } else {
                addCriterionForJDBCDate(IProductGlossaryDAO.LastEditDate +
                    " not in", values, "lastEditDate");

                return this;
            }
        }

        public Criteria andLastEditDateIn(java.util.Date[] values) {
            if (values.length == 1) {
                return andLastEditDateEqualTo(values[0]);
            } else {
                addCriterionForJDBCDate(IProductGlossaryDAO.LastEditDate +
                    " in", Arrays.asList(values), "lastEditDate");

                return this;
            }
        }

        public Criteria andLastEditDateNotIn(java.util.Date[] values) {
            if (values.length == 1) {
                return andLastEditDateNotEqualTo(values[0]);
            } else {
                addCriterionForJDBCDate(IProductGlossaryDAO.LastEditDate +
                    " not in", Arrays.asList(values), "lastEditDate");

                return this;
            }
        }

        public Criteria andLastEditDateIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.LastEditDate + " in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andLastEditDateNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.LastEditDate + " not in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andLastEditDateBetween(java.util.Date value1,
            java.util.Date value2) {
            addCriterionForJDBCDate(IProductGlossaryDAO.LastEditDate +
                " between", value1, value2, "lastEditDate");

            return this;
        }

        public Criteria andLastEditDateNotBetween(java.util.Date value1,
            java.util.Date value2) {
            addCriterionForJDBCDate(IProductGlossaryDAO.LastEditDate +
                " not between", value1, value2, "lastEditDate");

            return this;
        }

        public Criteria andNameIsNull() {
            addCriterion(IProductGlossaryDAO.Name + " is null");

            return this;
        }

        public Criteria andNameIsNotNull() {
            addCriterion(IProductGlossaryDAO.Name + " is not null");

            return this;
        }

        public Criteria andNameIsNotEmpty() {
            addCriterion(IProductGlossaryDAO.Name + " is not null AND " +
                IProductGlossaryDAO.Name + " <> ''");

            return this;
        }

        public Criteria andNameIsEmpty() {
            addCriterion("(" + IProductGlossaryDAO.Name + " is null OR " +
                IProductGlossaryDAO.Name + " = '')");

            return this;
        }

        public Criteria andNameEqualTo(String value) {
            addCriterion(IProductGlossaryDAO.Name + " = ", value, "name");

            return this;
        }

        public Criteria andNameEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.Name);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andNameEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.Name + " = ", subQueryBean, dao);

            return this;
        }

        public Criteria andNameNotEqualTo(String value) {
            addCriterion(IProductGlossaryDAO.Name + " <>", value, "name");

            return this;
        }

        public Criteria andNameNotEqualToOrIsNull(String value) {
            addCriterion(IProductGlossaryDAO.Name + " is null OR " +
                IProductGlossaryDAO.Name + " <>", value, "name");

            return this;
        }

        public Criteria andNameNotEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.Name);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andNameNotEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.Name + " <> ", subQueryBean, dao);

            return this;
        }

        public Criteria andNameGreaterThan(String value) {
            addCriterion(IProductGlossaryDAO.Name + " >", value, "name");

            return this;
        }

        public Criteria andNameGreaterThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.Name);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andNameGreaterThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.Name + " > ", subQueryBean, dao);

            return this;
        }

        public Criteria andNameGreaterThanOrEqualTo(String value) {
            addCriterion(IProductGlossaryDAO.Name + " >=", value, "name");

            return this;
        }

        public Criteria andNameGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.Name);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andNameGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.Name + " >= ", subQueryBean, dao);

            return this;
        }

        public Criteria andNameLessThan(String value) {
            addCriterion(IProductGlossaryDAO.Name + " <", value, "name");

            return this;
        }

        public Criteria andNameLessThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.Name);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andNameLessThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.Name + " < ", subQueryBean, dao);

            return this;
        }

        public Criteria andNameLessThanOrEqualTo(String value) {
            addCriterion(IProductGlossaryDAO.Name + " <=", value, "name");

            return this;
        }

        public Criteria andNameLessThanOrEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.Name);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andNameLessThanOrEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.Name + " <= ", subQueryBean, dao);

            return this;
        }

        public Criteria andNameLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductGlossaryDAO.Name + " like", buffer.toString(),
                "name");

            return this;
        }

        public Criteria andNameNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductGlossaryDAO.Name + " not like",
                buffer.toString(), "name");

            return this;
        }

        public Criteria andNameIn(List<String> values) {
            if (values.size() == 1) {
                return andNameEqualTo(values.get(0));
            } else {
                addCriterion(IProductGlossaryDAO.Name + " in", values, "name");

                return this;
            }
        }

        public Criteria andNameNotIn(List<String> values) {
            if (values.size() == 1) {
                return andNameNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductGlossaryDAO.Name + " not in", values,
                    "name");

                return this;
            }
        }

        public Criteria andNameIn(String[] values) {
            if (values.length == 1) {
                return andNameEqualTo(values[0]);
            } else {
                addCriterion(IProductGlossaryDAO.Name + " in",
                    Arrays.asList(values), "name");

                return this;
            }
        }

        public Criteria andNameNotIn(String[] values) {
            if (values.length == 1) {
                return andNameNotEqualTo(values[0]);
            } else {
                addCriterion(IProductGlossaryDAO.Name + " not in",
                    Arrays.asList(values), "name");

                return this;
            }
        }

        public Criteria andNameIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.Name + " in ", subQueryBean, dao);

            return this;
        }

        public Criteria andNameNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.Name + " not in ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andNameBetween(String value1, String value2) {
            addCriterion(IProductGlossaryDAO.Name + " between", value1, value2,
                "name");

            return this;
        }

        public Criteria andNameNotBetween(String value1, String value2) {
            addCriterion(IProductGlossaryDAO.Name + " not between", value1,
                value2, "name");

            return this;
        }

        public Criteria andProductIdIsNull() {
            addCriterion(IProductGlossaryDAO.ProductId + " is null");

            return this;
        }

        public Criteria andProductIdIsNotNull() {
            addCriterion(IProductGlossaryDAO.ProductId + " is not null");

            return this;
        }

        public Criteria andProductIdIsNotEmpty() {
            addCriterion(IProductGlossaryDAO.ProductId + " is not null AND " +
                IProductGlossaryDAO.ProductId + " <> ''");

            return this;
        }

        public Criteria andProductIdIsEmpty() {
            addCriterion("(" + IProductGlossaryDAO.ProductId + " is null OR " +
                IProductGlossaryDAO.ProductId + " = '')");

            return this;
        }

        public Criteria andProductIdEqualTo(long value) {
            return andProductIdEqualTo(Long.valueOf(value));
        }

        public Criteria andProductIdEqualTo(java.lang.Long value) {
            addCriterion(IProductGlossaryDAO.ProductId + " = ", value,
                "productId");

            return this;
        }

        public Criteria andProductIdEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.ProductId);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductIdEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.ProductId + " = ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andProductIdNotEqualTo(long value) {
            return andProductIdNotEqualTo(Long.valueOf(value));
        }

        public Criteria andProductIdNotEqualTo(java.lang.Long value) {
            addCriterion(IProductGlossaryDAO.ProductId + " <>", value,
                "productId");

            return this;
        }

        public Criteria andProductIdNotEqualToOrIsNull(long value) {
            return andProductIdNotEqualToOrIsNull(Long.valueOf(value));
        }

        public Criteria andProductIdNotEqualToOrIsNull(java.lang.Long value) {
            addCriterion(IProductGlossaryDAO.ProductId + " is null OR " +
                IProductGlossaryDAO.ProductId + " <>", value, "productId");

            return this;
        }

        public Criteria andProductIdNotEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.ProductId);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductIdNotEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.ProductId + " <> ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andProductIdGreaterThan(long value) {
            return andProductIdGreaterThan(Long.valueOf(value));
        }

        public Criteria andProductIdGreaterThan(java.lang.Long value) {
            addCriterion(IProductGlossaryDAO.ProductId + " >", value,
                "productId");

            return this;
        }

        public Criteria andProductIdGreaterThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.ProductId);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductIdGreaterThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.ProductId + " > ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andProductIdGreaterThanOrEqualTo(long value) {
            return andProductIdGreaterThanOrEqualTo(Long.valueOf(value));
        }

        public Criteria andProductIdGreaterThanOrEqualTo(java.lang.Long value) {
            addCriterion(IProductGlossaryDAO.ProductId + " >=", value,
                "productId");

            return this;
        }

        public Criteria andProductIdGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.ProductId);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductIdGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.ProductId + " >= ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andProductIdLessThan(long value) {
            return andProductIdLessThan(Long.valueOf(value));
        }

        public Criteria andProductIdLessThan(java.lang.Long value) {
            addCriterion(IProductGlossaryDAO.ProductId + " <", value,
                "productId");

            return this;
        }

        public Criteria andProductIdLessThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.ProductId);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductIdLessThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.ProductId + " < ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andProductIdLessThanOrEqualTo(long value) {
            return andProductIdLessThanOrEqualTo(Long.valueOf(value));
        }

        public Criteria andProductIdLessThanOrEqualTo(java.lang.Long value) {
            addCriterion(IProductGlossaryDAO.ProductId + " <=", value,
                "productId");

            return this;
        }

        public Criteria andProductIdLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.ProductId);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductIdLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.ProductId + " <= ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andProductIdIn(long[] values) {
            if (values.length == 1) {
                return andProductIdEqualTo((java.lang.Long) values[0]);
            } else {
                addCriterion(IProductGlossaryDAO.ProductId + " in", values,
                    "productId");

                return this;
            }
        }

        public Criteria andProductIdNotIn(long[] values) {
            if (values.length == 1) {
                return andProductIdNotEqualTo((java.lang.Long) values[0]);
            } else {
                addCriterion(IProductGlossaryDAO.ProductId + " not in", values,
                    "productId");

                return this;
            }
        }

        public Criteria andProductIdIn(List<java.lang.Long> values) {
            if (values.size() == 1) {
                return andProductIdEqualTo(values.get(0));
            } else {
                addCriterion(IProductGlossaryDAO.ProductId + " in", values,
                    "productId");

                return this;
            }
        }

        public Criteria andProductIdNotIn(List<java.lang.Long> values) {
            if (values.size() == 1) {
                return andProductIdNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductGlossaryDAO.ProductId + " not in", values,
                    "productId");

                return this;
            }
        }

        public Criteria andProductIdIn(java.lang.Long[] values) {
            if (values.length == 1) {
                return andProductIdEqualTo(values[0]);
            } else {
                addCriterion(IProductGlossaryDAO.ProductId + " in",
                    Arrays.asList(values), "productId");

                return this;
            }
        }

        public Criteria andProductIdNotIn(java.lang.Long[] values) {
            if (values.length == 1) {
                return andProductIdNotEqualTo(values[0]);
            } else {
                addCriterion(IProductGlossaryDAO.ProductId + " not in",
                    Arrays.asList(values), "productId");

                return this;
            }
        }

        public Criteria andProductIdIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.ProductId + " in ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andProductIdNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.ProductId + " not in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductIdBetween(long value1, long value2) {
            addCriterion(IProductGlossaryDAO.ProductId + " between", value1,
                value2, "productId");

            return this;
        }

        public Criteria andProductIdBetween(java.lang.Long value1,
            java.lang.Long value2) {
            addCriterion(IProductGlossaryDAO.ProductId + " between", value1,
                value2, "productId");

            return this;
        }

        public Criteria andProductIdNotBetween(long value1, long value2) {
            addCriterion(IProductGlossaryDAO.ProductId + " not between",
                value1, value2, "productId");

            return this;
        }

        public Criteria andProductIdNotBetween(java.lang.Long value1,
            java.lang.Long value2) {
            addCriterion(IProductGlossaryDAO.ProductId + " not between",
                value1, value2, "productId");

            return this;
        }

        public Criteria andRemarksIsNull() {
            addCriterion(IProductGlossaryDAO.Remarks + " is null");

            return this;
        }

        public Criteria andRemarksIsNotNull() {
            addCriterion(IProductGlossaryDAO.Remarks + " is not null");

            return this;
        }

        public Criteria andRemarksIsNotEmpty() {
            addCriterion(IProductGlossaryDAO.Remarks + " is not null AND " +
                IProductGlossaryDAO.Remarks + " <> ''");

            return this;
        }

        public Criteria andRemarksIsEmpty() {
            addCriterion("(" + IProductGlossaryDAO.Remarks + " is null OR " +
                IProductGlossaryDAO.Remarks + " = '')");

            return this;
        }

        public Criteria andRemarksEqualTo(String value) {
            addCriterion(IProductGlossaryDAO.Remarks + " = ", value, "remarks");

            return this;
        }

        public Criteria andRemarksEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.Remarks);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andRemarksEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.Remarks + " = ", subQueryBean, dao);

            return this;
        }

        public Criteria andRemarksNotEqualTo(String value) {
            addCriterion(IProductGlossaryDAO.Remarks + " <>", value, "remarks");

            return this;
        }

        public Criteria andRemarksNotEqualToOrIsNull(String value) {
            addCriterion(IProductGlossaryDAO.Remarks + " is null OR " +
                IProductGlossaryDAO.Remarks + " <>", value, "remarks");

            return this;
        }

        public Criteria andRemarksNotEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.Remarks);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andRemarksNotEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.Remarks + " <> ", subQueryBean, dao);

            return this;
        }

        public Criteria andRemarksGreaterThan(String value) {
            addCriterion(IProductGlossaryDAO.Remarks + " >", value, "remarks");

            return this;
        }

        public Criteria andRemarksGreaterThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.Remarks);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andRemarksGreaterThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.Remarks + " > ", subQueryBean, dao);

            return this;
        }

        public Criteria andRemarksGreaterThanOrEqualTo(String value) {
            addCriterion(IProductGlossaryDAO.Remarks + " >=", value, "remarks");

            return this;
        }

        public Criteria andRemarksGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.Remarks);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andRemarksGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.Remarks + " >= ", subQueryBean, dao);

            return this;
        }

        public Criteria andRemarksLessThan(String value) {
            addCriterion(IProductGlossaryDAO.Remarks + " <", value, "remarks");

            return this;
        }

        public Criteria andRemarksLessThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.Remarks);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andRemarksLessThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.Remarks + " < ", subQueryBean, dao);

            return this;
        }

        public Criteria andRemarksLessThanOrEqualTo(String value) {
            addCriterion(IProductGlossaryDAO.Remarks + " <=", value, "remarks");

            return this;
        }

        public Criteria andRemarksLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.Remarks);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andRemarksLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.Remarks + " <= ", subQueryBean, dao);

            return this;
        }

        public Criteria andRemarksLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductGlossaryDAO.Remarks + " like",
                buffer.toString(), "remarks");

            return this;
        }

        public Criteria andRemarksNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductGlossaryDAO.Remarks + " not like",
                buffer.toString(), "remarks");

            return this;
        }

        public Criteria andRemarksIn(List<String> values) {
            if (values.size() == 1) {
                return andRemarksEqualTo(values.get(0));
            } else {
                addCriterion(IProductGlossaryDAO.Remarks + " in", values,
                    "remarks");

                return this;
            }
        }

        public Criteria andRemarksNotIn(List<String> values) {
            if (values.size() == 1) {
                return andRemarksNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductGlossaryDAO.Remarks + " not in", values,
                    "remarks");

                return this;
            }
        }

        public Criteria andRemarksIn(String[] values) {
            if (values.length == 1) {
                return andRemarksEqualTo(values[0]);
            } else {
                addCriterion(IProductGlossaryDAO.Remarks + " in",
                    Arrays.asList(values), "remarks");

                return this;
            }
        }

        public Criteria andRemarksNotIn(String[] values) {
            if (values.length == 1) {
                return andRemarksNotEqualTo(values[0]);
            } else {
                addCriterion(IProductGlossaryDAO.Remarks + " not in",
                    Arrays.asList(values), "remarks");

                return this;
            }
        }

        public Criteria andRemarksIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.Remarks + " in ", subQueryBean, dao);

            return this;
        }

        public Criteria andRemarksNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.Remarks + " not in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andRemarksBetween(String value1, String value2) {
            addCriterion(IProductGlossaryDAO.Remarks + " between", value1,
                value2, "remarks");

            return this;
        }

        public Criteria andRemarksNotBetween(String value1, String value2) {
            addCriterion(IProductGlossaryDAO.Remarks + " not between", value1,
                value2, "remarks");

            return this;
        }

        public Criteria andStatusIsNull() {
            addCriterion(IProductGlossaryDAO.Status + " is null");

            return this;
        }

        public Criteria andStatusIsNotNull() {
            addCriterion(IProductGlossaryDAO.Status + " is not null");

            return this;
        }

        public Criteria andStatusIsNotEmpty() {
            addCriterion(IProductGlossaryDAO.Status + " is not null AND " +
                IProductGlossaryDAO.Status + " <> ''");

            return this;
        }

        public Criteria andStatusIsEmpty() {
            addCriterion("(" + IProductGlossaryDAO.Status + " is null OR " +
                IProductGlossaryDAO.Status + " = '')");

            return this;
        }

        public Criteria andStatusEqualTo(String value) {
            addCriterion(IProductGlossaryDAO.Status + " = ", value, "status");

            return this;
        }

        public Criteria andStatusEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.Status);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andStatusEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.Status + " = ", subQueryBean, dao);

            return this;
        }

        public Criteria andStatusNotEqualTo(String value) {
            addCriterion(IProductGlossaryDAO.Status + " <>", value, "status");

            return this;
        }

        public Criteria andStatusNotEqualToOrIsNull(String value) {
            addCriterion(IProductGlossaryDAO.Status + " is null OR " +
                IProductGlossaryDAO.Status + " <>", value, "status");

            return this;
        }

        public Criteria andStatusNotEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.Status);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andStatusNotEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.Status + " <> ", subQueryBean, dao);

            return this;
        }

        public Criteria andStatusGreaterThan(String value) {
            addCriterion(IProductGlossaryDAO.Status + " >", value, "status");

            return this;
        }

        public Criteria andStatusGreaterThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.Status);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andStatusGreaterThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.Status + " > ", subQueryBean, dao);

            return this;
        }

        public Criteria andStatusGreaterThanOrEqualTo(String value) {
            addCriterion(IProductGlossaryDAO.Status + " >=", value, "status");

            return this;
        }

        public Criteria andStatusGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.Status);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andStatusGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.Status + " >= ", subQueryBean, dao);

            return this;
        }

        public Criteria andStatusLessThan(String value) {
            addCriterion(IProductGlossaryDAO.Status + " <", value, "status");

            return this;
        }

        public Criteria andStatusLessThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.Status);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andStatusLessThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.Status + " < ", subQueryBean, dao);

            return this;
        }

        public Criteria andStatusLessThanOrEqualTo(String value) {
            addCriterion(IProductGlossaryDAO.Status + " <=", value, "status");

            return this;
        }

        public Criteria andStatusLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.Status);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andStatusLessThanOrEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.Status + " <= ", subQueryBean, dao);

            return this;
        }

        public Criteria andStatusLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductGlossaryDAO.Status + " like",
                buffer.toString(), "status");

            return this;
        }

        public Criteria andStatusNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductGlossaryDAO.Status + " not like",
                buffer.toString(), "status");

            return this;
        }

        public Criteria andStatusIn(List<String> values) {
            if (values.size() == 1) {
                return andStatusEqualTo(values.get(0));
            } else {
                addCriterion(IProductGlossaryDAO.Status + " in", values,
                    "status");

                return this;
            }
        }

        public Criteria andStatusNotIn(List<String> values) {
            if (values.size() == 1) {
                return andStatusNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductGlossaryDAO.Status + " not in", values,
                    "status");

                return this;
            }
        }

        public Criteria andStatusIn(String[] values) {
            if (values.length == 1) {
                return andStatusEqualTo(values[0]);
            } else {
                addCriterion(IProductGlossaryDAO.Status + " in",
                    Arrays.asList(values), "status");

                return this;
            }
        }

        public Criteria andStatusNotIn(String[] values) {
            if (values.length == 1) {
                return andStatusNotEqualTo(values[0]);
            } else {
                addCriterion(IProductGlossaryDAO.Status + " not in",
                    Arrays.asList(values), "status");

                return this;
            }
        }

        public Criteria andStatusIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.Status + " in ", subQueryBean, dao);

            return this;
        }

        public Criteria andStatusNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.Status + " not in ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andStatusBetween(String value1, String value2) {
            addCriterion(IProductGlossaryDAO.Status + " between", value1,
                value2, "status");

            return this;
        }

        public Criteria andStatusNotBetween(String value1, String value2) {
            addCriterion(IProductGlossaryDAO.Status + " not between", value1,
                value2, "status");

            return this;
        }

        public Criteria andSinceVersionIdIsNull() {
            addCriterion(IProductGlossaryDAO.SinceVersionId + " is null");

            return this;
        }

        public Criteria andSinceVersionIdIsNotNull() {
            addCriterion(IProductGlossaryDAO.SinceVersionId + " is not null");

            return this;
        }

        public Criteria andSinceVersionIdIsNotEmpty() {
            addCriterion(IProductGlossaryDAO.SinceVersionId +
                " is not null AND " + IProductGlossaryDAO.SinceVersionId +
                " <> ''");

            return this;
        }

        public Criteria andSinceVersionIdIsEmpty() {
            addCriterion("(" + IProductGlossaryDAO.SinceVersionId +
                " is null OR " + IProductGlossaryDAO.SinceVersionId + " = '')");

            return this;
        }

        public Criteria andSinceVersionIdEqualTo(long value) {
            return andSinceVersionIdEqualTo(Long.valueOf(value));
        }

        public Criteria andSinceVersionIdEqualTo(java.lang.Long value) {
            addCriterion(IProductGlossaryDAO.SinceVersionId + " = ", value,
                "sinceVersionId");

            return this;
        }

        public Criteria andSinceVersionIdEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.SinceVersionId);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andSinceVersionIdEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.SinceVersionId + " = ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andSinceVersionIdNotEqualTo(long value) {
            return andSinceVersionIdNotEqualTo(Long.valueOf(value));
        }

        public Criteria andSinceVersionIdNotEqualTo(java.lang.Long value) {
            addCriterion(IProductGlossaryDAO.SinceVersionId + " <>", value,
                "sinceVersionId");

            return this;
        }

        public Criteria andSinceVersionIdNotEqualToOrIsNull(long value) {
            return andSinceVersionIdNotEqualToOrIsNull(Long.valueOf(value));
        }

        public Criteria andSinceVersionIdNotEqualToOrIsNull(
            java.lang.Long value) {
            addCriterion(IProductGlossaryDAO.SinceVersionId + " is null OR " +
                IProductGlossaryDAO.SinceVersionId + " <>", value,
                "sinceVersionId");

            return this;
        }

        public Criteria andSinceVersionIdNotEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.SinceVersionId);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andSinceVersionIdNotEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.SinceVersionId + " <> ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andSinceVersionIdGreaterThan(long value) {
            return andSinceVersionIdGreaterThan(Long.valueOf(value));
        }

        public Criteria andSinceVersionIdGreaterThan(java.lang.Long value) {
            addCriterion(IProductGlossaryDAO.SinceVersionId + " >", value,
                "sinceVersionId");

            return this;
        }

        public Criteria andSinceVersionIdGreaterThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.SinceVersionId);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andSinceVersionIdGreaterThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.SinceVersionId + " > ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andSinceVersionIdGreaterThanOrEqualTo(long value) {
            return andSinceVersionIdGreaterThanOrEqualTo(Long.valueOf(value));
        }

        public Criteria andSinceVersionIdGreaterThanOrEqualTo(
            java.lang.Long value) {
            addCriterion(IProductGlossaryDAO.SinceVersionId + " >=", value,
                "sinceVersionId");

            return this;
        }

        public Criteria andSinceVersionIdGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.SinceVersionId);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andSinceVersionIdGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.SinceVersionId + " >= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andSinceVersionIdLessThan(long value) {
            return andSinceVersionIdLessThan(Long.valueOf(value));
        }

        public Criteria andSinceVersionIdLessThan(java.lang.Long value) {
            addCriterion(IProductGlossaryDAO.SinceVersionId + " <", value,
                "sinceVersionId");

            return this;
        }

        public Criteria andSinceVersionIdLessThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.SinceVersionId);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andSinceVersionIdLessThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.SinceVersionId + " < ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andSinceVersionIdLessThanOrEqualTo(long value) {
            return andSinceVersionIdLessThanOrEqualTo(Long.valueOf(value));
        }

        public Criteria andSinceVersionIdLessThanOrEqualTo(java.lang.Long value) {
            addCriterion(IProductGlossaryDAO.SinceVersionId + " <=", value,
                "sinceVersionId");

            return this;
        }

        public Criteria andSinceVersionIdLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.SinceVersionId);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andSinceVersionIdLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.SinceVersionId + " <= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andSinceVersionIdIn(long[] values) {
            if (values.length == 1) {
                return andSinceVersionIdEqualTo((java.lang.Long) values[0]);
            } else {
                addCriterion(IProductGlossaryDAO.SinceVersionId + " in",
                    values, "sinceVersionId");

                return this;
            }
        }

        public Criteria andSinceVersionIdNotIn(long[] values) {
            if (values.length == 1) {
                return andSinceVersionIdNotEqualTo((java.lang.Long) values[0]);
            } else {
                addCriterion(IProductGlossaryDAO.SinceVersionId + " not in",
                    values, "sinceVersionId");

                return this;
            }
        }

        public Criteria andSinceVersionIdIn(List<java.lang.Long> values) {
            if (values.size() == 1) {
                return andSinceVersionIdEqualTo(values.get(0));
            } else {
                addCriterion(IProductGlossaryDAO.SinceVersionId + " in",
                    values, "sinceVersionId");

                return this;
            }
        }

        public Criteria andSinceVersionIdNotIn(List<java.lang.Long> values) {
            if (values.size() == 1) {
                return andSinceVersionIdNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductGlossaryDAO.SinceVersionId + " not in",
                    values, "sinceVersionId");

                return this;
            }
        }

        public Criteria andSinceVersionIdIn(java.lang.Long[] values) {
            if (values.length == 1) {
                return andSinceVersionIdEqualTo(values[0]);
            } else {
                addCriterion(IProductGlossaryDAO.SinceVersionId + " in",
                    Arrays.asList(values), "sinceVersionId");

                return this;
            }
        }

        public Criteria andSinceVersionIdNotIn(java.lang.Long[] values) {
            if (values.length == 1) {
                return andSinceVersionIdNotEqualTo(values[0]);
            } else {
                addCriterion(IProductGlossaryDAO.SinceVersionId + " not in",
                    Arrays.asList(values), "sinceVersionId");

                return this;
            }
        }

        public Criteria andSinceVersionIdIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.SinceVersionId + " in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andSinceVersionIdNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.SinceVersionId + " not in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andSinceVersionIdBetween(long value1, long value2) {
            addCriterion(IProductGlossaryDAO.SinceVersionId + " between",
                value1, value2, "sinceVersionId");

            return this;
        }

        public Criteria andSinceVersionIdBetween(java.lang.Long value1,
            java.lang.Long value2) {
            addCriterion(IProductGlossaryDAO.SinceVersionId + " between",
                value1, value2, "sinceVersionId");

            return this;
        }

        public Criteria andSinceVersionIdNotBetween(long value1, long value2) {
            addCriterion(IProductGlossaryDAO.SinceVersionId + " not between",
                value1, value2, "sinceVersionId");

            return this;
        }

        public Criteria andSinceVersionIdNotBetween(java.lang.Long value1,
            java.lang.Long value2) {
            addCriterion(IProductGlossaryDAO.SinceVersionId + " not between",
                value1, value2, "sinceVersionId");

            return this;
        }

        public Criteria andTypeIsNull() {
            addCriterion(IProductGlossaryDAO.Type + " is null");

            return this;
        }

        public Criteria andTypeIsNotNull() {
            addCriterion(IProductGlossaryDAO.Type + " is not null");

            return this;
        }

        public Criteria andTypeIsNotEmpty() {
            addCriterion(IProductGlossaryDAO.Type + " is not null AND " +
                IProductGlossaryDAO.Type + " <> ''");

            return this;
        }

        public Criteria andTypeIsEmpty() {
            addCriterion("(" + IProductGlossaryDAO.Type + " is null OR " +
                IProductGlossaryDAO.Type + " = '')");

            return this;
        }

        public Criteria andTypeEqualTo(String value) {
            addCriterion(IProductGlossaryDAO.Type + " = ", value, "type");

            return this;
        }

        public Criteria andTypeEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.Type);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andTypeEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.Type + " = ", subQueryBean, dao);

            return this;
        }

        public Criteria andTypeNotEqualTo(String value) {
            addCriterion(IProductGlossaryDAO.Type + " <>", value, "type");

            return this;
        }

        public Criteria andTypeNotEqualToOrIsNull(String value) {
            addCriterion(IProductGlossaryDAO.Type + " is null OR " +
                IProductGlossaryDAO.Type + " <>", value, "type");

            return this;
        }

        public Criteria andTypeNotEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.Type);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andTypeNotEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.Type + " <> ", subQueryBean, dao);

            return this;
        }

        public Criteria andTypeGreaterThan(String value) {
            addCriterion(IProductGlossaryDAO.Type + " >", value, "type");

            return this;
        }

        public Criteria andTypeGreaterThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.Type);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andTypeGreaterThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.Type + " > ", subQueryBean, dao);

            return this;
        }

        public Criteria andTypeGreaterThanOrEqualTo(String value) {
            addCriterion(IProductGlossaryDAO.Type + " >=", value, "type");

            return this;
        }

        public Criteria andTypeGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.Type);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andTypeGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.Type + " >= ", subQueryBean, dao);

            return this;
        }

        public Criteria andTypeLessThan(String value) {
            addCriterion(IProductGlossaryDAO.Type + " <", value, "type");

            return this;
        }

        public Criteria andTypeLessThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.Type);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andTypeLessThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.Type + " < ", subQueryBean, dao);

            return this;
        }

        public Criteria andTypeLessThanOrEqualTo(String value) {
            addCriterion(IProductGlossaryDAO.Type + " <=", value, "type");

            return this;
        }

        public Criteria andTypeLessThanOrEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.Type);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andTypeLessThanOrEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.Type + " <= ", subQueryBean, dao);

            return this;
        }

        public Criteria andTypeLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductGlossaryDAO.Type + " like", buffer.toString(),
                "type");

            return this;
        }

        public Criteria andTypeNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductGlossaryDAO.Type + " not like",
                buffer.toString(), "type");

            return this;
        }

        public Criteria andTypeIn(List<String> values) {
            if (values.size() == 1) {
                return andTypeEqualTo(values.get(0));
            } else {
                addCriterion(IProductGlossaryDAO.Type + " in", values, "type");

                return this;
            }
        }

        public Criteria andTypeNotIn(List<String> values) {
            if (values.size() == 1) {
                return andTypeNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductGlossaryDAO.Type + " not in", values,
                    "type");

                return this;
            }
        }

        public Criteria andTypeIn(String[] values) {
            if (values.length == 1) {
                return andTypeEqualTo(values[0]);
            } else {
                addCriterion(IProductGlossaryDAO.Type + " in",
                    Arrays.asList(values), "type");

                return this;
            }
        }

        public Criteria andTypeNotIn(String[] values) {
            if (values.length == 1) {
                return andTypeNotEqualTo(values[0]);
            } else {
                addCriterion(IProductGlossaryDAO.Type + " not in",
                    Arrays.asList(values), "type");

                return this;
            }
        }

        public Criteria andTypeIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.Type + " in ", subQueryBean, dao);

            return this;
        }

        public Criteria andTypeNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.Type + " not in ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andTypeBetween(String value1, String value2) {
            addCriterion(IProductGlossaryDAO.Type + " between", value1, value2,
                "type");

            return this;
        }

        public Criteria andTypeNotBetween(String value1, String value2) {
            addCriterion(IProductGlossaryDAO.Type + " not between", value1,
                value2, "type");

            return this;
        }

        public Criteria andLastEditorNameIsNull() {
            addCriterion(IProductGlossaryDAO.LastEditorName + " is null");

            return this;
        }

        public Criteria andLastEditorNameIsNotNull() {
            addCriterion(IProductGlossaryDAO.LastEditorName + " is not null");

            return this;
        }

        public Criteria andLastEditorNameIsNotEmpty() {
            addCriterion(IProductGlossaryDAO.LastEditorName +
                " is not null AND " + IProductGlossaryDAO.LastEditorName +
                " <> ''");

            return this;
        }

        public Criteria andLastEditorNameIsEmpty() {
            addCriterion("(" + IProductGlossaryDAO.LastEditorName +
                " is null OR " + IProductGlossaryDAO.LastEditorName + " = '')");

            return this;
        }

        public Criteria andLastEditorNameEqualTo(String value) {
            addCriterion(IProductGlossaryDAO.LastEditorName + " = ", value,
                "lastEditorName");

            return this;
        }

        public Criteria andLastEditorNameEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.LastEditorName);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andLastEditorNameEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.LastEditorName + " = ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andLastEditorNameNotEqualTo(String value) {
            addCriterion(IProductGlossaryDAO.LastEditorName + " <>", value,
                "lastEditorName");

            return this;
        }

        public Criteria andLastEditorNameNotEqualToOrIsNull(String value) {
            addCriterion(IProductGlossaryDAO.LastEditorName + " is null OR " +
                IProductGlossaryDAO.LastEditorName + " <>", value,
                "lastEditorName");

            return this;
        }

        public Criteria andLastEditorNameNotEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.LastEditorName);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andLastEditorNameNotEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.LastEditorName + " <> ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andLastEditorNameGreaterThan(String value) {
            addCriterion(IProductGlossaryDAO.LastEditorName + " >", value,
                "lastEditorName");

            return this;
        }

        public Criteria andLastEditorNameGreaterThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.LastEditorName);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andLastEditorNameGreaterThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.LastEditorName + " > ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andLastEditorNameGreaterThanOrEqualTo(String value) {
            addCriterion(IProductGlossaryDAO.LastEditorName + " >=", value,
                "lastEditorName");

            return this;
        }

        public Criteria andLastEditorNameGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.LastEditorName);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andLastEditorNameGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.LastEditorName + " >= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andLastEditorNameLessThan(String value) {
            addCriterion(IProductGlossaryDAO.LastEditorName + " <", value,
                "lastEditorName");

            return this;
        }

        public Criteria andLastEditorNameLessThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.LastEditorName);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andLastEditorNameLessThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.LastEditorName + " < ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andLastEditorNameLessThanOrEqualTo(String value) {
            addCriterion(IProductGlossaryDAO.LastEditorName + " <=", value,
                "lastEditorName");

            return this;
        }

        public Criteria andLastEditorNameLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.LastEditorName);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andLastEditorNameLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.LastEditorName + " <= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andLastEditorNameLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductGlossaryDAO.LastEditorName + " like",
                buffer.toString(), "lastEditorName");

            return this;
        }

        public Criteria andLastEditorNameNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductGlossaryDAO.LastEditorName + " not like",
                buffer.toString(), "lastEditorName");

            return this;
        }

        public Criteria andLastEditorNameIn(List<String> values) {
            if (values.size() == 1) {
                return andLastEditorNameEqualTo(values.get(0));
            } else {
                addCriterion(IProductGlossaryDAO.LastEditorName + " in",
                    values, "lastEditorName");

                return this;
            }
        }

        public Criteria andLastEditorNameNotIn(List<String> values) {
            if (values.size() == 1) {
                return andLastEditorNameNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductGlossaryDAO.LastEditorName + " not in",
                    values, "lastEditorName");

                return this;
            }
        }

        public Criteria andLastEditorNameIn(String[] values) {
            if (values.length == 1) {
                return andLastEditorNameEqualTo(values[0]);
            } else {
                addCriterion(IProductGlossaryDAO.LastEditorName + " in",
                    Arrays.asList(values), "lastEditorName");

                return this;
            }
        }

        public Criteria andLastEditorNameNotIn(String[] values) {
            if (values.length == 1) {
                return andLastEditorNameNotEqualTo(values[0]);
            } else {
                addCriterion(IProductGlossaryDAO.LastEditorName + " not in",
                    Arrays.asList(values), "lastEditorName");

                return this;
            }
        }

        public Criteria andLastEditorNameIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.LastEditorName + " in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andLastEditorNameNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.LastEditorName + " not in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andLastEditorNameBetween(String value1, String value2) {
            addCriterion(IProductGlossaryDAO.LastEditorName + " between",
                value1, value2, "lastEditorName");

            return this;
        }

        public Criteria andLastEditorNameNotBetween(String value1, String value2) {
            addCriterion(IProductGlossaryDAO.LastEditorName + " not between",
                value1, value2, "lastEditorName");

            return this;
        }

        public Criteria andSinceVersionIsNull() {
            addCriterion(IProductGlossaryDAO.SinceVersion + " is null");

            return this;
        }

        public Criteria andSinceVersionIsNotNull() {
            addCriterion(IProductGlossaryDAO.SinceVersion + " is not null");

            return this;
        }

        public Criteria andSinceVersionIsNotEmpty() {
            addCriterion(IProductGlossaryDAO.SinceVersion +
                " is not null AND " + IProductGlossaryDAO.SinceVersion +
                " <> ''");

            return this;
        }

        public Criteria andSinceVersionIsEmpty() {
            addCriterion("(" + IProductGlossaryDAO.SinceVersion +
                " is null OR " + IProductGlossaryDAO.SinceVersion + " = '')");

            return this;
        }

        public Criteria andSinceVersionEqualTo(String value) {
            addCriterion(IProductGlossaryDAO.SinceVersion + " = ", value,
                "sinceVersion");

            return this;
        }

        public Criteria andSinceVersionEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.SinceVersion);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andSinceVersionEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.SinceVersion + " = ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andSinceVersionNotEqualTo(String value) {
            addCriterion(IProductGlossaryDAO.SinceVersion + " <>", value,
                "sinceVersion");

            return this;
        }

        public Criteria andSinceVersionNotEqualToOrIsNull(String value) {
            addCriterion(IProductGlossaryDAO.SinceVersion + " is null OR " +
                IProductGlossaryDAO.SinceVersion + " <>", value, "sinceVersion");

            return this;
        }

        public Criteria andSinceVersionNotEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.SinceVersion);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andSinceVersionNotEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.SinceVersion + " <> ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andSinceVersionGreaterThan(String value) {
            addCriterion(IProductGlossaryDAO.SinceVersion + " >", value,
                "sinceVersion");

            return this;
        }

        public Criteria andSinceVersionGreaterThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.SinceVersion);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andSinceVersionGreaterThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.SinceVersion + " > ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andSinceVersionGreaterThanOrEqualTo(String value) {
            addCriterion(IProductGlossaryDAO.SinceVersion + " >=", value,
                "sinceVersion");

            return this;
        }

        public Criteria andSinceVersionGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.SinceVersion);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andSinceVersionGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.SinceVersion + " >= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andSinceVersionLessThan(String value) {
            addCriterion(IProductGlossaryDAO.SinceVersion + " <", value,
                "sinceVersion");

            return this;
        }

        public Criteria andSinceVersionLessThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.SinceVersion);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andSinceVersionLessThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.SinceVersion + " < ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andSinceVersionLessThanOrEqualTo(String value) {
            addCriterion(IProductGlossaryDAO.SinceVersion + " <=", value,
                "sinceVersion");

            return this;
        }

        public Criteria andSinceVersionLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.SinceVersion);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andSinceVersionLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.SinceVersion + " <= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andSinceVersionLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductGlossaryDAO.SinceVersion + " like",
                buffer.toString(), "sinceVersion");

            return this;
        }

        public Criteria andSinceVersionNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductGlossaryDAO.SinceVersion + " not like",
                buffer.toString(), "sinceVersion");

            return this;
        }

        public Criteria andSinceVersionIn(List<String> values) {
            if (values.size() == 1) {
                return andSinceVersionEqualTo(values.get(0));
            } else {
                addCriterion(IProductGlossaryDAO.SinceVersion + " in", values,
                    "sinceVersion");

                return this;
            }
        }

        public Criteria andSinceVersionNotIn(List<String> values) {
            if (values.size() == 1) {
                return andSinceVersionNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductGlossaryDAO.SinceVersion + " not in",
                    values, "sinceVersion");

                return this;
            }
        }

        public Criteria andSinceVersionIn(String[] values) {
            if (values.length == 1) {
                return andSinceVersionEqualTo(values[0]);
            } else {
                addCriterion(IProductGlossaryDAO.SinceVersion + " in",
                    Arrays.asList(values), "sinceVersion");

                return this;
            }
        }

        public Criteria andSinceVersionNotIn(String[] values) {
            if (values.length == 1) {
                return andSinceVersionNotEqualTo(values[0]);
            } else {
                addCriterion(IProductGlossaryDAO.SinceVersion + " not in",
                    Arrays.asList(values), "sinceVersion");

                return this;
            }
        }

        public Criteria andSinceVersionIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.SinceVersion + " in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andSinceVersionNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.SinceVersion + " not in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andSinceVersionBetween(String value1, String value2) {
            addCriterion(IProductGlossaryDAO.SinceVersion + " between", value1,
                value2, "sinceVersion");

            return this;
        }

        public Criteria andSinceVersionNotBetween(String value1, String value2) {
            addCriterion(IProductGlossaryDAO.SinceVersion + " not between",
                value1, value2, "sinceVersion");

            return this;
        }

        public Criteria andProductDefineIdIsNull() {
            addCriterion(IProductGlossaryDAO.ProductDefineId + " is null");

            return this;
        }

        public Criteria andProductDefineIdIsNotNull() {
            addCriterion(IProductGlossaryDAO.ProductDefineId + " is not null");

            return this;
        }

        public Criteria andProductDefineIdIsNotEmpty() {
            addCriterion(IProductGlossaryDAO.ProductDefineId +
                " is not null AND " + IProductGlossaryDAO.ProductDefineId +
                " <> ''");

            return this;
        }

        public Criteria andProductDefineIdIsEmpty() {
            addCriterion("(" + IProductGlossaryDAO.ProductDefineId +
                " is null OR " + IProductGlossaryDAO.ProductDefineId +
                " = '')");

            return this;
        }

        public Criteria andProductDefineIdEqualTo(long value) {
            return andProductDefineIdEqualTo(Long.valueOf(value));
        }

        public Criteria andProductDefineIdEqualTo(java.lang.Long value) {
            addCriterion(IProductGlossaryDAO.ProductDefineId + " = ", value,
                "productDefineId");

            return this;
        }

        public Criteria andProductDefineIdEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.ProductDefineId);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductDefineIdEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.ProductDefineId + " = ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductDefineIdNotEqualTo(long value) {
            return andProductDefineIdNotEqualTo(Long.valueOf(value));
        }

        public Criteria andProductDefineIdNotEqualTo(java.lang.Long value) {
            addCriterion(IProductGlossaryDAO.ProductDefineId + " <>", value,
                "productDefineId");

            return this;
        }

        public Criteria andProductDefineIdNotEqualToOrIsNull(long value) {
            return andProductDefineIdNotEqualToOrIsNull(Long.valueOf(value));
        }

        public Criteria andProductDefineIdNotEqualToOrIsNull(
            java.lang.Long value) {
            addCriterion(IProductGlossaryDAO.ProductDefineId + " is null OR " +
                IProductGlossaryDAO.ProductDefineId + " <>", value,
                "productDefineId");

            return this;
        }

        public Criteria andProductDefineIdNotEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.ProductDefineId);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductDefineIdNotEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.ProductDefineId + " <> ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductDefineIdGreaterThan(long value) {
            return andProductDefineIdGreaterThan(Long.valueOf(value));
        }

        public Criteria andProductDefineIdGreaterThan(java.lang.Long value) {
            addCriterion(IProductGlossaryDAO.ProductDefineId + " >", value,
                "productDefineId");

            return this;
        }

        public Criteria andProductDefineIdGreaterThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.ProductDefineId);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductDefineIdGreaterThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.ProductDefineId + " > ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductDefineIdGreaterThanOrEqualTo(long value) {
            return andProductDefineIdGreaterThanOrEqualTo(Long.valueOf(value));
        }

        public Criteria andProductDefineIdGreaterThanOrEqualTo(
            java.lang.Long value) {
            addCriterion(IProductGlossaryDAO.ProductDefineId + " >=", value,
                "productDefineId");

            return this;
        }

        public Criteria andProductDefineIdGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.ProductDefineId);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductDefineIdGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.ProductDefineId + " >= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductDefineIdLessThan(long value) {
            return andProductDefineIdLessThan(Long.valueOf(value));
        }

        public Criteria andProductDefineIdLessThan(java.lang.Long value) {
            addCriterion(IProductGlossaryDAO.ProductDefineId + " <", value,
                "productDefineId");

            return this;
        }

        public Criteria andProductDefineIdLessThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.ProductDefineId);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductDefineIdLessThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.ProductDefineId + " < ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductDefineIdLessThanOrEqualTo(long value) {
            return andProductDefineIdLessThanOrEqualTo(Long.valueOf(value));
        }

        public Criteria andProductDefineIdLessThanOrEqualTo(
            java.lang.Long value) {
            addCriterion(IProductGlossaryDAO.ProductDefineId + " <=", value,
                "productDefineId");

            return this;
        }

        public Criteria andProductDefineIdLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryDAO.ProductDefineId);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductDefineIdLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.ProductDefineId + " <= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductDefineIdIn(long[] values) {
            if (values.length == 1) {
                return andProductDefineIdEqualTo((java.lang.Long) values[0]);
            } else {
                addCriterion(IProductGlossaryDAO.ProductDefineId + " in",
                    values, "productDefineId");

                return this;
            }
        }

        public Criteria andProductDefineIdNotIn(long[] values) {
            if (values.length == 1) {
                return andProductDefineIdNotEqualTo((java.lang.Long) values[0]);
            } else {
                addCriterion(IProductGlossaryDAO.ProductDefineId + " not in",
                    values, "productDefineId");

                return this;
            }
        }

        public Criteria andProductDefineIdIn(List<java.lang.Long> values) {
            if (values.size() == 1) {
                return andProductDefineIdEqualTo(values.get(0));
            } else {
                addCriterion(IProductGlossaryDAO.ProductDefineId + " in",
                    values, "productDefineId");

                return this;
            }
        }

        public Criteria andProductDefineIdNotIn(List<java.lang.Long> values) {
            if (values.size() == 1) {
                return andProductDefineIdNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductGlossaryDAO.ProductDefineId + " not in",
                    values, "productDefineId");

                return this;
            }
        }

        public Criteria andProductDefineIdIn(java.lang.Long[] values) {
            if (values.length == 1) {
                return andProductDefineIdEqualTo(values[0]);
            } else {
                addCriterion(IProductGlossaryDAO.ProductDefineId + " in",
                    Arrays.asList(values), "productDefineId");

                return this;
            }
        }

        public Criteria andProductDefineIdNotIn(java.lang.Long[] values) {
            if (values.length == 1) {
                return andProductDefineIdNotEqualTo(values[0]);
            } else {
                addCriterion(IProductGlossaryDAO.ProductDefineId + " not in",
                    Arrays.asList(values), "productDefineId");

                return this;
            }
        }

        public Criteria andProductDefineIdIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.ProductDefineId + " in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductDefineIdNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryDAO.ProductDefineId + " not in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductDefineIdBetween(long value1, long value2) {
            addCriterion(IProductGlossaryDAO.ProductDefineId + " between",
                value1, value2, "productDefineId");

            return this;
        }

        public Criteria andProductDefineIdBetween(java.lang.Long value1,
            java.lang.Long value2) {
            addCriterion(IProductGlossaryDAO.ProductDefineId + " between",
                value1, value2, "productDefineId");

            return this;
        }

        public Criteria andProductDefineIdNotBetween(long value1, long value2) {
            addCriterion(IProductGlossaryDAO.ProductDefineId + " not between",
                value1, value2, "productDefineId");

            return this;
        }

        public Criteria andProductDefineIdNotBetween(java.lang.Long value1,
            java.lang.Long value2) {
            addCriterion(IProductGlossaryDAO.ProductDefineId + " not between",
                value1, value2, "productDefineId");

            return this;
        }
    }
}
